﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Stockholm.SOA.Kaskelot.WCF.ServiceContracts;
using Stockholm.SOA.Kaskelot.WCF.DataContracts;
using Kaskelot.SP.Core;
using System.ServiceModel;
using Stockholm.SOA.Kaskelot.WCF.FaultContracts;

namespace Kaskelot.SP.Services
{
	public class ByggnadService : BaseService<IKaskelotService>
	{
		public Byggnad GetByggnad(Guid valId, Guid id)
		{
			Byggnad result = null;
			try
			{
				result = this.channel.GetByggnad(valId, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetByggnad", string.Format("Error getting byggnad with id {0} and valId {1}", id, valId), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public IEnumerable<ByggnadFull> GetByggnadList(IEnumerable<Guid> idList)
		{
			IEnumerable<ByggnadFull> res = null;

			try
			{
				res = this.channel.GetByggnadList(ApplicationContext.Current.Val.Id, idList);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetByggnadList", string.Format("Error getting byggnad list"), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return res;
		}

		public Byggnad GetByggnad(Guid id)
		{
			Byggnad result = null;
			try
			{
				result = this.channel.GetByggnad(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetByggnad", string.Format("Error getting byggnad with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public void UpdateByggnad(Byggnad byggnad, bool skipWriteCheck = false)
		{
			if(!skipWriteCheck)
				base.CheckWriteAllowed();

			try
			{
				this.channel.UpdateByggnad(byggnad);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "UpdateByggnad", string.Format("Error updating byggnad with id {0}", byggnad.Id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public IList<Byggnad> GetByggnader()
		{
			IList<Byggnad> result = new List<Byggnad>();
			try
			{
				result = this.channel.GetByggnader(ApplicationContext.Current.Val.Id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetByggnader", "Error getting byggnader", ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public Guid CreateByggnad(Byggnad b)
		{
			base.CheckWriteAllowed();
			Guid result = Guid.Empty;
			try
			{
				result = this.channel.CreateByggnad(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "CreateByggnad", "Error creating byggnader", ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
			return result;
		}

		public void DeleteByggnad(Byggnad b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.DeleteByggnad(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "DeleteByggnad", string.Format("Error deleting byggnad with id {0}", b.Id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public IList<ByggnadSearchResult> SearchByggnader(ByggnadSearchParameters parameters)
		{
			IList<ByggnadSearchResult> result = null;
			try
			{
				result = this.channel.SearchByggnader(ApplicationContext.Current.Val.Id, parameters);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "SearchByggnad", "Error searching for byggnader", ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public IList<Forsamling> GetForsamlingar(Guid? valkretsId)
		{
			IList<Forsamling> result = null;
			try
			{
				result = this.channel.GetForsamlingar(ApplicationContext.Current.Val.Id, valkretsId);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetForsamlingar", string.Format("Error getting församlingar for valkrets {0}", valkretsId.ToString()), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public IList<ByggnadHandelseLogg> GetByggnadHandelseLoggByByggnadId(Guid id)
		{
			IList<ByggnadHandelseLogg> result = null;
			try
			{
				result = this.channel.GetByggnadHandelseLoggByByggnadId(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetByggnadHandelseLoggByByggnadId", string.Format("Error getting händelselogg for byggnad with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public void UpdateByggnadHandelseLogg(ByggnadHandelseLogg bhl)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.UpdateByggnadHandelseLogg(bhl);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "UpdateByggnadHandelseLogg", string.Format("Error updating händelselogg for byggnad with id {0}", bhl.ByggnadId), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public void DeleteByggnadHandelseLogg(Guid id)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.DeleteByggnadHandelseLogg(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "DeleteByggnadHandelseLogg", string.Format("Error deleting händelselogg with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public IList<GetLokalListByByggnadView> GetLokalListByByggnad(Guid id)
		{
			IList<GetLokalListByByggnadView> result = null;
			try
			{
				result = this.channel.GetLokalListByByggnad(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetLokalListByByggnad", string.Format("Error getting lokallista for byggnad with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public IList<GetMaterielListByByggnadView> GetMaterielListByByggnad(Guid id)
		{
			IList<GetMaterielListByByggnadView> result = null;
			try
			{
				result = this.channel.GetMaterielListByByggnad(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetMaterielListByByggnad", string.Format("Error getting materiellista for byggnad with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public void CreateByggnadHandelseLogg(ByggnadHandelseLogg b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.CreateByggnadHandelseLogg(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "CreateByggnadHandelseLogg", string.Format("Error creating händelselogg for byggnad with id {0}", b.ByggnadId), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public ByggnadHandelseLogg GetByggnadHandelseLogg(Guid id)
		{
			ByggnadHandelseLogg result = null;
			try
			{
				result = this.channel.GetByggnadHandelseLogg(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetByggnadHandelseLogg", string.Format("Error getting händelselogg with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public Lokal GetLokal(Guid id)
		{
			Lokal result = null;
			try
			{
				result = this.channel.GetLokal(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetLokal", string.Format("Error getting lokal with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public void CreateLokal(Lokal b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.CreateLokal(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "CreateLokal", "Error creating lokal", ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public void UpdateLokal(Lokal b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.UpdateLokal(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "UpdateLokal", string.Format("Error updating lokal with id {0}", b.Id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public void DeleteLokal(Guid id)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.DeleteLokal(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "DeleteLokal", string.Format("Error deleting lokal with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public Materiel GetMateriel(Guid id)
		{
			Materiel result = null;
			try
			{
				result = this.channel.GetMateriel(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetMateriel", string.Format("Error getting materiel with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public void CreateMateriel(Materiel b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.CreateMateriel(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "CreateMateriel", "Error creating materiel", ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public void UpdateMateriel(Materiel b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.UpdateMateriel(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "UpdateMateriel", string.Format("Error updating materiel with id {0}", b.Id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public void DeleteMateriel(Guid id)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.DeleteMateriel(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "DeleteMateriel", string.Format("Error deleting materiel with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public IList<Valdistrikt> GetValdistrikt(Guid? forsamlingId)
		{
			IList<Valdistrikt> result = null;
			try
			{
				result = this.channel.GetValdistriktList(ApplicationContext.Current.Val.Id, forsamlingId);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetValdistrikt", string.Format("Error getting valdistrikt for församling with id {0}", forsamlingId), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public IList<GetKontaktpersonListByByggnadView> GetKontaktPersonListByByggnad(Guid byggnadId)
		{
			IList<GetKontaktpersonListByByggnadView> result = null;
			try
			{
				result = this.channel.GetKontaktPersonListByByggnad(ApplicationContext.Current.Val.Id, byggnadId);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetKontaktPersonListByByggnad", string.Format("Error getting kontaktpersonlista for byggnad with id {0}", byggnadId), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public IList<Skylt> GetSkyltListByByggnad(Guid id)
		{
			IList<Skylt> result = null;
			try
			{
				result = this.channel.GetSkyltListByByggnad(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetSkyltListByByggnad", string.Format("Error getting skyltlista for byggnad with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public Skylt GetSkylt(Guid id)
		{
			Skylt result = null;
			try
			{
				result = this.channel.GetSkylt(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "GetSkylt", string.Format("Error getting skylt with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}

			return result;
		}

		public void CreateSkylt(Skylt b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.CreateSkylt(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "CreateSkylt", "Error creating skylt", ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public void UpdateSkylt(Skylt b)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.UpdateSkylt(b);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "UpdateSkylt", string.Format("Error updating skylt with id {0}", b.Id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}

		public void DeleteSkylt(Guid id)
		{
			base.CheckWriteAllowed();
			try
			{
				this.channel.DeleteSkylt(ApplicationContext.Current.Val.Id, id);
			}
			catch (FaultException<ErrorInformation> ex)
			{
				Logger.LogError(this, LayerNames.Services, "DeleteSkylt", string.Format("Error deleting skylt with id {0}", id), ex);
                throw new ApplicationException(ex.Detail.ServiceError);
			}
		}
	}
}
